home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK2.toast / Development Kits (Disc 2) / OpenDoc / OpenDoc Development / Debugging Support / OpenDoc™ Source Code / Storage / Bento / CM / CMErrOps.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-28  |  29.9 KB  |  585 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        CMErrOps.c
  3.  
  4.     Contains:    Container Manager Error Handler Support Operations
  5.  
  6.     Written by:    Ira L. Ruben
  7.  
  8.     Owned by:    Ed Lai
  9.  
  10.     Copyright:    © 1991 - 1996 by Apple Computer, Inc., all rights reserved.
  11.  
  12.     Change History (most recent first):
  13.  
  14.          <3>     6/14/96    NP        10020: remove warnings.
  15.          <2>     1/15/96    TJ        Cleaned Up
  16.          <3>     8/24/95    EL        1274602, 1277989: bad container name when
  17.                                     deleting object with use count > 1.
  18.          <2>     8/26/94    EL        #1181622 Ownership update.
  19.          <1>      2/3/94    EL        first checked in
  20.  
  21.     To Do:
  22. */
  23.  
  24. /*---------------------------------------------------------------------------*
  25.  |                                                                           |
  26.  |                        <<<     CMErrOps.c      >>>                        |
  27.  |                                                                           |
  28.  |            Container Manager Error Handler Support Operations             |
  29.  |                                                                           |
  30.  |                               Ira L. Ruben                                |
  31.  |                                 12/06/91                                  |
  32.  |                                                                           |
  33.  |                  Copyright Apple Computer, Inc. 1991-1994                 |
  34.  |                           All rights reserved.                            |
  35.  |                                                                           |
  36.  *---------------------------------------------------------------------------*
  37.  
  38.  All the routines in this file deal with error reporting.  They are provided as a
  39.  convenience to allow the user (usually a handler writer) to convert error codes (defined
  40.  in CMAPIErr.h) to their corresponding message strings.
  41. */
  42.  
  43.  
  44. #include <stddef.h>
  45. #include <stdarg.h>
  46. #include <ctype.h>
  47. #include <string.h>
  48. #include <stdio.h>
  49.  
  50. #ifndef __CMTYPES__
  51. #include "CMTypes.h"
  52. #endif
  53. #ifndef __CM_API_TYPES__
  54. #include "CMAPITyp.h"
  55. #endif
  56. #ifndef __CM_API__
  57. #include "CMAPI.h"
  58. #endif
  59. #ifndef __TOCENTRIES__
  60. #include "TOCEnts.h"   
  61. #endif
  62. #ifndef __TOCOBJECTS__
  63. #include "TOCObjs.h"   
  64. #endif
  65. #ifndef __CONTAINEROPS__
  66. #include "Containr.h"  
  67. #endif
  68. #ifndef __SESSIONDATA__
  69. #include "Session.h"          
  70. #endif
  71. #ifndef __ERRORRPT__
  72. #include "ErrorRpt.h"      
  73. #endif
  74. #ifndef __UTILITYROUTINES__
  75. #include "Utility.h"        
  76. #endif
  77.                                                                     
  78.                                                                     CM_CFUNCTIONS
  79.  
  80. /* The following generates a segment directive for Mac only due to 32K Jump Table             */
  81. /* Limitations.  If you don't know what I'm talking about don't worry about it.  The        */
  82. /* default is not to generate the pragma.  Theoritically unknown pragmas in ANSI won't    */
  83. /* choke compilers that don't recognize them.                                                                                      */
  84.  
  85. #if CM_MPW
  86. #pragma segment CMErrorHandlerOps
  87. #endif
  88.  
  89.  
  90. #define MaxMsgLen 1024                                        /* no msg should be bigger than this                    */
  91.  
  92.  
  93. /*------------------------------------------*
  94.  | my_strtoul - parse a integer in a string |
  95.  *------------------------------------------*
  96.  
  97.  This routine is my private implementation of the standard ANSII library routine strtoul().
  98.  It taks a pointer to a string which is assumed to be pointing at some digits and returns
  99.  the resulting integer.  The pointer to the character that stopped the scan is returned
  100.  in endptr.
  101.  
  102.  This routine is coded here for the following reasons:
  103.  
  104.          (1).  strtoul() is a ANSI standard routine which another installation might not have
  105.                     if they don't have a full ANSI runtime library.
  106.                     
  107.         (2).  I don't need all the generality of strtoul().  The base is always assumed as 10
  108.                     here and endptr is never NULL.
  109.                     
  110.         (3).    There is a bug in the Mac MPW strtoul() routine!  Ah-ha, the REAL reason!  It 
  111.                     seems that MPW's strtoul() treats characters as signed.  We could have characters
  112.                     with values larger than 127 in our strings.  This causes MPW's strtoul() to
  113.                     fail in wierd ways (like when it passes such charas to isalnum()).
  114. */
  115.  
  116. static CM_ULONG CM_NEAR my_strtoul(CM_CHAR *s, CM_CHAR **endptr)
  117. {
  118.     CM_ULONG    digit, value = 0;
  119.     
  120.     for (;;) {                                                        /* scan until we don't hit a digit...                        */
  121.         switch (*s) {                                                /* done this way to be *completely* portable!        */
  122.             case '0':    digit = 0; break;                /* yuk!     (there MUST be another way to do this)    */
  123.             case '1':    digit = 1; break;                /*        But it must be done WITHOUT assuming  */
  124.             case '2':    digit = 2; break;                /*                a character set ordering dependence!    */
  125.             case '3':    digit = 3; break;
  126.             case '4':    digit = 4; break;
  127.             case '5':    digit = 5; break;
  128.             case '6':    digit = 6; break;
  129.             case '7':    digit = 7; break;
  130.             case '8':    digit = 8; break;
  131.             case '9':    digit = 9; break;
  132.             default:    *endptr = s;                        /* return ptr to delimiting non-digit                        */
  133.                                 return (value);                    /* return collected value                                                */
  134.         } /* switch */
  135.         
  136.         value = value * 10 + digit;                    /* build up the (decimal) number                                */
  137.         ++s;                                                                /* ready to look at next character                            */
  138.     } /* for */
  139. }
  140.  
  141.  
  142. /*-------------------------------------------------------*
  143.  | CMAddMsgInserts - add all inserts to an error message |
  144.  *-------------------------------------------------------*
  145.  
  146.  This routine takes the (error) message string in msgString and replaces all substrings
  147.  of the form "^n" with the inserts from the variable arg list of insert strings.  The
  148.  function returns the edited msgString as its result.
  149.  
  150.  The string buffer must be passed in msgString.  Its max length is also specified but this
  151.  must be a value less than or equal 1024 (not including delimiting null). The message will
  152.  be truncated to fit in the buffer.  The string pointer is returned as the function
  153.  result.
  154.  
  155.  The substring "^0" is replaced with the first insert. "^1" is replaced with the second
  156.  insert, and so on.  It is assumed that there are enough insert strings to cover all the
  157.  "^n"s called for (not unlike printf()).
  158.  
  159.  Note, the "^n"s in the message string do not have to be in ascending order.  Thus "^1"
  160.  could occur before "^0" in the msgString.
  161. */
  162.  
  163. CM_CHAR CM_PTR * CM_VARARGS CMAddMsgInserts(CM_CHAR CM_PTR *msgString, CMSize maxLength, ...)
  164. {
  165.     va_list inserts;
  166.  
  167.     va_start(inserts, maxLength);
  168.     CMVAddMsgInserts(msgString, maxLength, inserts);
  169.     va_end(inserts);
  170.     
  171.     return (msgString);
  172. }
  173.  
  174.  
  175. /*--------------------------------------------------------*
  176.  | CMVAddMsgInserts - add all inserts to an error message |
  177.  *--------------------------------------------------------*
  178.  
  179.  This routine is the same as CMAddMsgInserts() above, except that the extra (insert) 
  180.  arguments are given as a variable argument list as defined by the "stdarg" facility.
  181.  
  182.  This routine assumes the caller sets up and terminates the variable arg list using the
  183.  "stdarg.h" calls as follows:
  184.  
  185.              #include <stdarg.h>
  186.             
  187.              callersRoutine(args, ...)
  188.             {
  189.                 va_list inserts;
  190.                 
  191.                 - - -
  192.                 
  193.                 va_start(inserts, args);
  194.                 CMVAddMsgInserts(msgString, maxLength, inserts);
  195.                 va_end(inserts);
  196.                 
  197.                 - - -
  198.             }
  199.             
  200.  See CMAddMsgInserts() for further details.
  201. */
  202.  
  203. CM_CHAR CM_PTR * CM_FIXEDARGS CMVAddMsgInserts(CM_CHAR CM_PTR *msgString, CMSize maxLength,
  204.                                                                                            va_list inserts)
  205. {
  206.     CM_CHAR              c, *src, *dst, *p, *insert, msgString0[MaxMsgLen];
  207.     CM_ULONG            cnt = (unsigned long)maxLength;
  208.     CM_LONG                n;
  209.     va_list             inserts0 = inserts;
  210.     
  211.     src = strcpy(msgString0, (dst = msgString));
  212.     
  213.     while (((CMBoolean)(c = *src++)) && cnt > 0) {/* scan src buffer for "^n"s...                        */
  214.         if (c != '^') {                                                        /* if we don't hace an "^n"...                        */
  215.             *dst++ = c;                                                            /* ...just copy src to dst (output) buffer*/
  216.             --cnt;                                                                    /* ...make sure we don't exceed maxLen        */
  217.             continue;
  218.         }
  219.     
  220.         n = my_strtoul(src, &p);                                /* extract the insert number (n) from "^n"*/
  221.         if (p == src) {                                                        /* leave a lone "^" alone                                            */
  222.             *dst++ = c;                                                            /* ...they are treated like normal chars    */
  223.             --cnt;
  224.             continue;
  225.         }
  226.         
  227.         inserts = inserts0;                                                /* get n'th insert (there better be one!)    */
  228.         while (n-- >= 0)                                                    /* there's no way to chk that there isn't    */
  229.             insert = va_arg(inserts, CM_CHAR *);
  230.     
  231.         while (*insert && cnt > 0) {                            /* copy the insert to the dst buffer...     */
  232.             *dst++ = *insert++;
  233.             --cnt;                                                                    /* ..careful here too about going to far    */
  234.         }
  235.         
  236.         src = p;                                                                    /* point past "^n" in the input string        */
  237.     } /* while */                                                                /* keep scanning the src, copying to dst    */
  238.     
  239.     *dst = '\0';                                                                /* that's all there is to it!                            */
  240.     return (msgString);
  241. }
  242.  
  243.  
  244. #if 0 /* orignal code not used -- it's overkill (it's an insert-in-place algorithm) */
  245. /*--------------------------------------------------------*
  246.  | CMVAddMsgInserts - add all inserts to an error message |
  247.  *--------------------------------------------------------*
  248.  
  249.  This routine takes the (error) message string in msgString and replaces all substrings
  250.  of the form "^n" with the inserts from the variable arg list of insert strings.  The
  251.  function returns the edited msgString as its result.
  252.  
  253.  The string buffer must be passed in msgString.  Its max length is also specified but this
  254.  must be a value less than or equal 1024 (not including delimiting null). The message will
  255.  be truncated to fit in the buffer.  The string pointer is returned as the function
  256.  result.
  257.  
  258.  The substring "^0" is replaced with the first insert. "^1" is replaced with the second
  259.  insert, and so on.  It is assumed that there are enough insert strings to cover all the
  260.  "^n"s called for (not unlike printf()).
  261.  
  262.  Note, the "^n"s in the message string do not have to be in ascending order.  Thus "^1"
  263.  could occur before "^0" in the msgString.
  264. */
  265.  
  266. CM_CHAR CM_PTR * CM_FIXEDARGS CMVAddMsgInserts(CM_CHAR CM_PTR *msgString, CMSize maxLength,
  267.                                                                                            va_list inserts)
  268. {
  269.     CM_CHAR     *s, *p, *q, *x, *last, *insert, c;
  270.     CM_LONG        n;
  271.     CM_SHORT    msglen, inslen, signalLen, cnt;
  272.     va_list     inserts0 = inserts;
  273.     
  274.     s = msgString;                                                    /* get initial length and ptr to last char+1    */
  275.     while (*s++);
  276.     msglen = --s - msgString;
  277.     
  278.     while (--s > msgString) {                                /* scan msgString right-to-left for inserts...*/
  279.         if (*s != '^') continue;                            /* leave everything else along                                */
  280.         
  281.         n = my_strtoul(s+1, &x);                            /* extract the insert number                                    */
  282.         if (x == s + 1) continue;                            /* leave a lone "^" alone                                            */
  283.         signalLen = x - s;                                        /* this many chars must be replaced                        */
  284.         
  285.         inserts = inserts0;
  286.         while (n-- >= 0)                                            /* get the n'th insert (there better be one!)    */
  287.             insert = va_arg(inserts, CM_CHAR *);
  288.         inslen = strlen(insert);                            /* we need its length too                                            */
  289.         
  290.         cnt  = maxLen - msglen + signalLen;        /* accounts for deletion of the "^n" chars        */
  291.         
  292.         if (inslen > signalLen) {                            /* if expanding string with insert...                    */
  293.             p    = msgString + msglen;                    /* 1st position beyond end of current string    */
  294.             q      = p + inslen - signalLen;            /* q points to 1 beyond where to put last char*/
  295.             last = msgString + maxLen;                    /* 1 beyond the last char allowed in string        */
  296.             while (--p > s)                                         /* make room for insertion...                                    */ 
  297.                 if (--q < last) {                                    /* i.e., move chars right in insertion string    */
  298.                     *q = *p;
  299.                 } else                                                        /* we may have to truncate here!                            */
  300.                     cnt++;
  301.         } else if (inslen < signalLen) {            /* if contracting string for short insert...    */
  302.             q = s + signalLen;                                    /* ptr to the char immediately following "^n"    */
  303.             p = s + inslen;                                            /* ptr to end of inset (p < q)                                */ 
  304.             while (*p) *p++ = *q++;                            /* move chars left in msg string                            */
  305.         }
  306.         
  307.         p = s;
  308.         while (cnt && *insert) {                            /* insert the insert...                                             */
  309.             cnt--;
  310.             *p++ = *insert++;
  311.         }
  312.         
  313.         msglen = maxLen - cnt;                                /* update total length including insert                */
  314.         *(msgString + msglen) = '\0';                    /* add required null at end of msg string            */
  315.     } /* while */
  316.         
  317.     return (msgString);                                            /* return fully inserted msg string to caller    */
  318. }
  319. #endif
  320.  
  321.  
  322. /*---------------------------------------------------------------------------------------*
  323.  | CMErrorToFormattedString - return CM (error) message string corresponding to a message number |
  324.  *---------------------------------------------------------------------------------------*
  325.  
  326.  This routine takes a defined Container Manager (error) message number and its
  327.  corresponding insert strings and returns a (english) string corresponding to the message
  328.  number with the inserts filled into their proper positions. It is assumed the error
  329.  number and inserts were the ones reported to the error handler. 
  330.  
  331.  The string buffer must be passed in errorString.  Its max length is also specified but
  332.  this must be a value less than or equal 1024 (not including delimiting null).  The
  333.  message will be truncated to fit in the buffer.  The string pointer is returned as the
  334.  function result.
  335.  
  336.  This routine is provided as a convenience to easily convert the error codes and their
  337.  corresponding inserts to a printable string.
  338. */
  339.  
  340. CMErrorString CM_VARARGS CMErrorToFormattedString(CMErrorString errorString, CMSize maxLength, 
  341.                                                                                       CMErrorNbr errorNumber, ...)
  342. {
  343.     va_list inserts;
  344.  
  345.     va_start(inserts, errorNumber);
  346.     CMVErrorToFormattedString(errorString, maxLength, errorNumber, inserts);
  347.     va_end(inserts);
  348.     
  349.     return (errorString);
  350. }
  351.  
  352.  
  353. /*----------------------------------------------------------------------------------------*
  354.  | CMVErrorToFormattedString - return CM (error) message string corresponding to a message number |
  355.  *----------------------------------------------------------------------------------------*
  356.  
  357.  This routine is the same as CMErrorToFormattedString() above, except that the extra (inserts) 
  358.  arguments are given as a variable argument list as defined by the "stdarg" facility.
  359.  
  360.  This routine assumes the caller sets up and terminates the variable arg list using the
  361.  "stdarg.h" calls as follows:
  362.  
  363.              #include <stdarg.h>
  364.             
  365.              callersRoutine(args, ...)
  366.             {
  367.                 va_list inserts;
  368.                 
  369.                 - - -
  370.                 
  371.                 va_start(inserts, args);
  372.                 CMVErrorToFormattedString(errorString, maxLength, errorNumber, inserts);
  373.                 va_end(inserts);
  374.                 
  375.                 - - -
  376.             }
  377.             
  378.  See CMErrorToFormattedString() for further details.
  379. */
  380.  
  381. CMErrorString CM_FIXEDARGS CMVErrorToFormattedString(CMErrorString errorString, CMSize maxLength, 
  382.                                                                                         CMErrorNbr errorNumber, va_list inserts)
  383. {
  384.     CM_CHAR     *msgStr, msg[MaxMsgLen];
  385.     CM_CHAR        tmpStr[15];
  386.     CMBoolean    gotInserts = true;
  387.     
  388.     #define TheErrorList    switch (errorNumber) {
  389.     #define e0(n, s)                 case n:  msgStr = (CM_CHAR *)s; gotInserts = false; break
  390.     #define e1(n, s)                 case n:  msgStr = (CM_CHAR *)s; break
  391.     #define EndOfList(s)        default: msgStr = (CM_CHAR *)s; gotInserts = false; break;\
  392.                                                 }                                                                                                                 \
  393.                                                 strcpy((char *)msg, (char *)msgStr);
  394.     
  395.     /* To define a new error number and message, use the macro e1(n, s) if the string s     */
  396.     /* contains inserts.  Use e0(n, s) if there are no inserts.  DON'T FORGET TO UPDATE        */
  397.     /* CMErrno.h.                                                                                                                                                    */
  398.     
  399.     TheErrorList
  400.         /*----------------------------------------------------------------------------------*/
  401.         e1(CM_err_GenericMessage,     "^0");
  402.         e1(CM_err_BadTocSize,             "TOC index table size out of range (^0 <= range <= ^1)");
  403.         e1(CM_err_NoSession,                 "Unable to allocate session (task) global data");
  404.         e1(CM_err_NoHandler,                 "Cannot allocate space for handler for type \"^0\"");
  405.         e1(CM_err_BadWriteUse,            "Cannot do a CMOpenNewContainer(...^0...) with useFlags set for update-in-place");
  406.         e1(CM_err_NoContainer,            "Cannot allocate CCB space for type \"^0\"");
  407.         e1(CM_err_UndefMetaHandler, "Metahandler was not defined for type \"^0\"");
  408.         e1(CM_err_HandlerError,            "Allocation problem while looking up handler for type \"^0\"");
  409.         e1(CM_err_NullMetaPtr,            "Null metahandler pointer for type \"^0\"");
  410.         e1(CM_err_UndefRoutine,         "Handler routine(s) missing for operation type(s): ^0");
  411.         e1(CM_err_NoTOC,                        "Cannot allocate TOC for container \"^0\"");
  412.         e1(CM_err_BadReadUse,                "Cannot do a CMOpenContainer(...\"^0\"...) with useFlags set for ^1");
  413.         e1(CM_err_BadMagicBytes,        "Invalid magic byte sequence in label for container \"^0\" - expected \"^1\", got \"^2\"");
  414.         e1(CM_err_BadVersion,                "Invalid version fields in label for container \"^0\" - expected ^1.^2, got ^3.^4");
  415.         e1(CM_err_BadTOCRead,                "Incorrect byte length read while reading TOC for container \"^0\"");
  416.         e1(CM_err_NoObjEntry,                "Cannot allocate space for TOC object entry for container \"^0\"");
  417.         e1(CM_err_MultDef,                    "Multiple definition for TOC object ^0 for container \"^1\"");
  418.         e1(CM_err_NoPropEntry,            "Cannot allocate space for TOC property entry for container \"^0\"");
  419.         e1(CM_err_BadContinue,            "Invalid continued value (inconsistent types) in container \"^0\"");
  420.         e1(CM_err_NoValueEntry,            "Cannot allocate space for TOC value entry for container \"^0\"");
  421.         e1(CM_err_BadOffset,                "Invalid offset or value (^0, ^1) for TOC value entry for container \"^2\"");
  422.         e1(CM_err_UndefObjects,            "There is (are) ^0 undefined object(s) in container \"^1\"");
  423.         e1(CM_err_NoStrValue,                "Cannot allocate space for constant value in container \"^0\"");
  424.         e1(CM_err_DupBaseType,            "Cannot add dup base type \"^0\" to type \"^1\" in container \"^2\"");
  425.         e1(CM_err_BadTOCWrite,            "Incorrect byte length written while writing TOC for \"^0\"");
  426.         e1(CM_err_NotGlobalName,        "Have global name tied to value of wrong type in containter \"^0\"");
  427.         e1(CM_err_BadGNameWrite,        "Incorrect byte length written while writing global name \"^0\" in container \"^1\"");
  428.         e1(CM_err_DupGlobalName,        "Duplicate global name definition for \"^0\" in container \"^1\"");
  429.         e1(CM_err_MultGlblNames,        "Object ^0 alread defined -- trying to redefine it for \"^1\" (container \"^2\")");
  430.         e1(CM_err_NoGlobalName,            "Cannot allocate space for global name \"^0\" in container \"^1\"");
  431.         e1(CM_err_NoGNameLoad,            "Cannot allocate space for global name during load in container \"^0\"");
  432.         e1(CM_err_BadGNameRead,            "Incorrect byte length read while reading global name in container \"^0\"");
  433.         e1(CM_err_NotGName,                    "Invalid global name string read in container \"^0\"");
  434.         e1(CM_err_BadType,                    "Invalid ^0 type passed to ^1 for container \"^2\"");
  435.         e1(CM_err_2Containers,            "Objects not in same containers (containers \"^0\" and \"^1\")");
  436.         e1(CM_err_3Containers,            "Objects not in same containers (containers \"^0\", \"^1\", and \"^2\")");
  437.         e1(CM_err_MissingMinIDSeed,    "Min ID seed value missing in TOC object 1 in container \"^0\"");
  438.         e1(CM_err_MissingTOCObj,        "TOC object ID 1 missing in TOC in container \"^0\"");
  439.         e1(CM_err_NotConverting,        "Cannot use CMDefineValueData except for converting container \"^0\"");
  440.         e1(CM_err_BadDefineData,        "Attempt to define offset (^0) out of range in container \"^1\"");
  441.         e1(CM_err_BadValue,                    "Attempt to use a deleted value in container \"^0\"");
  442.         e1(CM_err_BadObject,                "Attempt to use a deleted object in container \"^0\"");
  443.         e1(CM_err_BadContainer,            "Container for ^0 (\"^1\") does not belong to the container being used (\"^2\")");
  444.         e1(CM_err_NoValue,                    "No value defined for object ID ^0, property \"^1\" in container \"^2\"");
  445.         e1(CM_err_HasValue,                    "Cannot set a (sub)value to an already defined value (container \"^0\")");
  446.         e1(CM_err_AlreadyReleased1,    "Attempting to release a value already completely released in container \"^0\"");
  447.         e1(CM_err_NotReleased,            "A dynamic value has not been fully released in container \"^0\"");
  448.         e1(CM_err_MissingFreeTotal,    "Total free space value missing in TOC object 1 in container \"^0\"");
  449.         e1(CM_err_DupType,                    "Attempt to insert two values with the same type (^0) in container \"^1\"");
  450.         e1(CM_err_HasNoValue,                "No value defined for CMReadValueData in container \"^0\"");
  451.         e1(CM_err_BadWrite,                    "Write error writing to container \"^0\"");
  452.         e1(CM_err_CantWriteGlbl,        "Cannot write to a global name in container \"^0\"");
  453.         e1(CM_err_Offset2Big,                "Write/insert offset (^0) beyond end of a value in container \"^1\"");
  454.         e1(CM_err_Internal1,                "Internal error! Unknown flags setting (0x^0)");
  455.         e1(CM_err_MissingIDSeed,        "ID seed value missing in TOC object 1 in container \"^0\"");
  456.         e1(CM_err_AmbiguousType,        "^0 object is ambiguous in container \"^1\"");
  457.         e1(CM_err_TypeNotGlobal,        "^0 object is not for a global name in container \"^1\"");
  458.         e1(CM_err_MissingFreeList,    "Internal error - empty free list for property in container \"^0\"");
  459.         e1(CM_err_NoNewValueHandler,"A \"new value\" handler is not defined for type \"^0\"");
  460.         e1(CM_err_UndefReference,        "Object ID ^0 from a reference is undefined in container \"^1\"");
  461.         e1(CM_err_BadObjectKind,        "Invalid kind of object -- expected ^0 in container \"^1\"");
  462.         e1(CM_err_WriteIllegal1,        "Cannot write to a container (\"^0\") opened for reading");
  463.         e1(CM_err_WriteIllegal2,        "Attempt to write to a protected object in container \"^0\"");
  464.         e1(CM_err_ReadIllegal,            "Cannot read from a container (\"^0\") opened for writing");
  465.         e1(CM_err_MissingSize,            "Size value missing in TOC object 1 in container \"^0\"");
  466.         e1(CM_err_BadSize,                    "Inconsistent size values between container label and TOC (container \"^0\")");
  467.         e1(CM_err_Internal2,                "Internal error! TOC offset to offset/size value not found in container \"^0\"");
  468.         e1(CM_err_CantDelete1,            "Attempt to delete to a protected object in container \"^0\"");
  469.         e1(CM_err_CantDelete2,            "Attempt to delete to a property with a protected value in container \"^0\"");
  470.         e1(CM_err_CantDelete3,            "Attempt to delete to a protected value in container \"^0\"");
  471.         e1(CM_err_StillOpen,                "Container \"^0\" is still open at session close time");
  472.         e1(CM_err_EmptyRead,                "Cannot read from an empty embedded container value (container \"^0\")");
  473.         e1(CM_err_NoEmbedding,            "Cannot allocate space to save embedding status while opening container \"^0\"");
  474.         e1(CM_err_BadGenNbr,                "Invalid generation number (^0) passed to ^1 (container \"^2\")");
  475.         e1(CM_err_NoRef,                        "Connot allocate space for an object reference in container \"^0\")");
  476.         e1(CM_err_CantGetBase,            "CMGetBaseValue() may only be called from a dynamic value handler in container \"^0\"");
  477.         e1(CM_err_MultTypeProp,            "Attempt to register a ^0 name (^1) in container \"^2\" -- already defined as a ^3");
  478.         e1(CM_err_NotSameMode,            "Embedded container (\"^0\") must be opened in same mode as its parent (\"^1\")");
  479.         e1(CM_err_CantDelete4,            "Cannot delete a value currently in use in container \"^0\"");
  480.         e1(CM_err_MissingHandler,        "Memory allocator and dealocator handlers must be supplied");
  481.         e1(CM_err_NoMissingBuffer,    "Unable to allocate private temporary buffer while opening type \"^0\"");
  482.         e1(CM_err_MoveIllegal,            "Cannot move a value in a container (\"^0\") not opened for writing");
  483.         e1(CM_err_DeleteIllegal,        "Attempt to delete ^0 in a container (\"^1\") not opened for writing");
  484.         e1(CM_err_BadDefineType,        "Attempt to define additional data for a immediate value in container \"^0\"");
  485.         e1(CM_err_NoDynExtensions,    "Cannot allocate space for TOC dynamic value entry for type \"^0\" in container \"^1\"");
  486.         e1(CM_err_HandlerRecursed,    "Attempt to use dynamic value handler for ^0() recursively in container \"^1\"");
  487.         e1(CM_err_BadRealValue,            "Invalid base (\"real\") value passed to ^0() in container \"^1\"");
  488.         e1(CM_err_NoMetahandler,        "A value operations metahandler is not defined for type \"^0\" in container \"^1\"");
  489.         e1(CM_err_NotDynValue,            "A \"use value\" metahandler did not create a dynamic value in container \"^0\"");
  490.         e1(CM_err_NoGlobalTable,        "Cannot allocate globally unique name table for container \"^0\"");
  491.         e1(CM_err_BadMetaSpec,            "Invalid metadata format specification (%^0) for type \"^1\" in container \"^2\"");
  492.         e1(CM_err_NoDeletesList,        "Internal error - empty \"deletes\" list for property in container \"^0\"");
  493.         e1(CM_err_NoDataPacket,            "Cannot allocate space for data packet for type \"^0\" in container \"^1\"");
  494.         e1(CM_err_BaseRelAttempted,    "A dynamic value release handler attempted to release its base in container \"^0\"");
  495.         e1(CM_err_NoDynMetahandler,    "\"Use value\" handler for type \"^0\" in container \"^1\" MUST return a metahandler");
  496.         e1(CM_err_MissingTotalSize,    "Total container size value missing in TOC object 1 in container \"^0\"");
  497.         e1(CM_err_Internal3,                "Internal error! TOC offset to container value not found in container \"^0\"");
  498.         e1(CM_err_AmbiguousUseFlags,"Ambiguous updating useFlags passed to CMOpenNewContainer(...\"^0\"...) - ^1");
  499.         e1(CM_err_NoTypeHandler,        "Dynamic value type handler not defined for updating in container \"^0\"");
  500.         e1(CM_err_NotDynamicValue,    "Dynamic value in container \"^0\" not created to access target for updating");
  501.         e1(CM_err_NoMetaDataHandler,"A \"metadata\" handler is not defined for type \"^0\"");
  502.         e1(CM_err_NoDataBuffer,            "Cannot allocate space for data I/O buffer in container \"^0\"");
  503.         e1(CM_err_BadUpdateRead,        "Incorrect byte length read while reading updates in container \"^0\"");
  504.         e1(CM_err_BadUpdateWrite,        "Write error while writing updates in container \"^0\"");
  505.         e1(CM_err_Internal4,                "Internal error! End-of-updates signal not detected in container \"^0\"");
  506.         e1(CM_err_Internal5,                "Internal error! TOC offset to updates TOC subsection not found in container \"^0\"");
  507.         e1(CM_err_NoNewValuesTOC,        "\"New values\" TOC offset/size missing in TOC object 1 in container \"^0\"");
  508.         e1(CM_err_wrappedIDs,                "Too many objects in container \"^0\" or next user object ID > 0xFFFFFFFF");
  509.         e1(CM_err_NoTouchedEntry,        "Cannot allocate space for recording updating operation in container \"^0\"");
  510.         e1(CM_err_NoUpdateObject,        "Container \"^0\" updating -- cannot find object ID ^1 to be ^2");
  511.         e1(CM_err_NoUpdateProperty,    "Container \"^0\" updating -- cannot find a property ID ^1 in object ID ^2 to be ^3");
  512.         e1(CM_err_BadUpdateControl,    "Container \"^0\" updating -- unknown control byte read (0x^1, during ^2)");
  513.         e1(CM_err_NoUpdateType,            "Container \"^0\" updating -- cannot find value (type ID ^1) in object ^2, property ^3");
  514.         e1(CM_err_UndefUpdateObject,"Container \"^0\" updating -- cannot find ^1 (ID ^2) to use in ^3");
  515.         e1(CM_err_UpdateBadGenNbr,    "Container \"^0\" updating -- invalid generation number (^1)");
  516.         e1(CM_err_BadInsertData,        "Container \"^0\" updating -- bad updating info (0 segment insert encountered)");
  517.         e1(CM_err_BadInsertOffset,    "Container \"^0\" updating -- insert offset (^1) beyond end of a value");
  518.         e1(CM_err_CantRepImmediate,    "Container \"^0\" updating -- attempt to replace non-immediate with immediate");
  519.         e1(CM_err_CantRepBaseType,    "Container \"^0\" updating -- attempt to replace non-base type value with a base type");
  520.         e1(CM_err_CantReference,        "Value and referenced object not in the same containers (containers \"^0\" and \"^1\")");
  521.         e1(CM_err_GloblaNameError,    "Allocation problem while looking up global name \"^0\" in container \"^1\"");
  522.         e1(CM_err_FlushErr,                    "Error detected in flushing output while closing container \"^0\"");
  523.         e1(CM_err_CantDelete5,            "Cannot delete an object with unreleased dynamic values in use in container \"^0\"");
  524.         e1(CM_err_NoTOCBuffer,            "Cannot allocate space for TOC I/O buffer in container \"^0\"");
  525.         e1(CM_err_BadTOCCode,                "Invalid TOC code read (0x^0) from TOC in container \"^1\"");
  526.         e1(CM_err_TOCoutOfSync,            "TOC reading out-of-sync (trying to read across buffer boundary) in container \"^0\"");
  527.         e1(CM_err_TOCParseErr1,            "TOC \"parse\" error - expected object ID, got 0x^0 in container \"^1\"");
  528.         e1(CM_err_TOCParseErr2,            "TOC \"parse\" error - got 0x^0 at an unexpected time in container \"^1\"");
  529.         e1(CM_err_Unsupported1,            "8-byte offset in container \"^0\" are not supported in this implementation");
  530.         e1(CM_err_CantDelete6,            "Cannot delete an object currently in use in container \"^0\"");
  531.         e1(CM_err_AlreadyReleased2,    "Attempting to release an object already completely released in container \"^0\"");
  532.         e1(CM_err_BadRefRead,                "Read error while reading references in container \"^0\"");
  533.         e1(CM_err_Internal6,                "Internal error! Missing reference property or value in container \"^0\"");
  534.         e1(CM_err_ZeroRefKey,                "Attempt to use a CMReference key of 0 in container \"^0\"");
  535.         e1(CM_err_NoRefShadowList,    "Cannot allocate space to record reference in container \"^0\"");
  536.     /*----------------------------------------------------------------------------------*/
  537.     EndOfList(strcat("Undefined error message for error #", cmltostr(errorNumber, 1, false, tmpStr)));
  538.  
  539.     if (gotInserts)
  540.         CMVAddMsgInserts(msg, maxLength, inserts);
  541.     
  542.     if ((CMSize)strlen(msg) <= maxLength)
  543.         strcpy((CM_CHAR *)errorString, (CM_CHAR *)msg);
  544.     else {
  545.         strncpy((CM_CHAR *)errorString, (CM_CHAR *)msg, (int)maxLength);
  546.         *(errorString + maxLength) = '\0';
  547.     }
  548.         
  549.     return (errorString);
  550. }
  551.  
  552.  
  553. /*------------------------------------------------------*
  554.  | CMReturnContainerName - get container identification |
  555.  *------------------------------------------------------*
  556.  
  557.  Generally the errors reported are provided with at least one insert that identifies which
  558.  container we're talking about.  The wording of the messages defined for the Container 
  559.  Manager assume this identification insert.  The identification takes the form of the
  560.  container "name" which is obtained from a handler routine provided for that purpose.
  561.  
  562.  For convenience, the name providing handler routine is allowed to be optional, i.e., the
  563.  user need not provide one.  This means every time we want to get the identification we
  564.  must test to see if the handler was provided.  This could be a waste of code space, 
  565.  particularly since we mostly use this for error reporting ("mostly" -- actually this is
  566.  the only context it is presenting used in).
  567.  
  568.  To avoid the space waste, this routine is provided to do the test and call the handler if
  569.  it exists.  If it doesn't exist the container type name (using the TYPENAMEx macro) is
  570.  used.  If it does, we use the handler.
  571.  
  572.  Note, this routine is available to users (usually handler writers) so that they too can
  573.  generalize their error reporting/message routines and word their messages with the
  574.  container identification. 
  575. */
  576.  
  577. CM_CHAR CM_PTR * CM_FIXEDARGS CMReturnContainerName(CMContainer container)
  578. {
  579.     return (((ContainerPtr)container)->handler.cmreturnContainerName == NULL ? 
  580.                         TYPENAMEx(container) :
  581.                         CMreturnContainerName(container));
  582. }
  583.                                                           
  584.                                                             CM_END_CFUNCTIONS
  585.